#include <board.h>
#include <rtthread.h>
#include <rtdevice.h>

#define echo_test_buffer_size (1024)
// 测试环境
// 串口2、3开启dma, 5、6不开启
// 缓冲区大小都为 128 字节

// echo test
// 3tx - 6rx
// 3rx - 6tx

// self test
// 2tx - 2rx
// 5tx - 5rx

static rt_device_t u2serial;
static rt_device_t u3serial;
static rt_device_t u5serial;
static rt_device_t u6serial;

static rt_uint32_t u2rx_length = 0;
static rt_uint32_t u2tx_length = 0;

static rt_uint32_t u3rx_length = 0;
static rt_uint32_t u3tx_length = 0;

static rt_uint32_t u5rx_length = 0;
static rt_uint32_t u5tx_length = 0;

static rt_uint32_t u6rx_length = 0;
static rt_uint32_t u6tx_length = 0;

static void echo_test_u3_thread_entry(void *parameter)
{
    char *uart_name = "uart3";
    static char rx_buffer[echo_test_buffer_size + 1];

    /* 查找串口设备 */
    u3serial = rt_device_find(uart_name);
    if (!u3serial)
    {
        rt_kprintf("find %s failed!\n", uart_name);
        return;
    }

    rt_device_open(u3serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);

    rt_ssize_t buf_datalen = 0;
    while (1)
    {
        rt_device_control(u3serial, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_datalen);
        int32_t recbLen = rt_device_read(u3serial, 0, rx_buffer, buf_datalen > 0 ? buf_datalen : 1);
        if (recbLen > 0)
        {
            u3rx_length += recbLen;
            u3tx_length += rt_device_write(u3serial, 0, rx_buffer, recbLen);
        }
    }
}

static void echo_test_u6_thread_entry(void *parameter)
{
    static char rx_buffer[echo_test_buffer_size + 1];
    rt_ssize_t buf_datalen = 0;
    while (1)
    {
        rt_device_control(u6serial, RT_SERIAL_CTRL_GET_UNREAD_BYTES_COUNT, (void *)&buf_datalen);
        int32_t recbLen = rt_device_read(u6serial, 0, rx_buffer, buf_datalen > 0 ? buf_datalen : 1);
        if (recbLen > 0)
        {
            u6rx_length += recbLen;
        }
    }
}

static void echo_test(void *parameter)
{
    static char tx_buffer[echo_test_buffer_size];

    for (uint32_t i = 0; i < sizeof(tx_buffer); i++)
        tx_buffer[i] = i;

    char *uart_name = "uart6";
    u6serial = rt_device_find(uart_name);
    if (!u6serial)
    {
        rt_kprintf("find %s failed!\n", uart_name);
        return;
    }

    rt_device_open(u6serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);

    rt_thread_startup(rt_thread_create("serial3", echo_test_u3_thread_entry, RT_NULL, 2048, 7, 5));
    rt_thread_startup(rt_thread_create("serial6", echo_test_u6_thread_entry, RT_NULL, 2048, 7, 5));

    uint32_t count = 0;
    uint32_t sendTotalCount = 0;
    while (1)
    {
        count++;

        // 不定长发送数据
        uint32_t sendCount = rand() % echo_test_buffer_size;
        u6tx_length += rt_device_write(u6serial, 0, tx_buffer, sendCount);
        sendTotalCount += sendCount;

        // 等待交叉发送完毕
        rt_thread_mdelay(15);

        if (count % 100 == 0)
        {
            srand(rt_tick_get());
            rt_kprintf("echo, uart3: tx: %ld, rx: %ld\r\n", u3tx_length, u3rx_length);
            rt_kprintf("echo, uart6: tx: %ld, rx: %ld\r\n", u6tx_length, u6rx_length);
            if (u3tx_length != u3rx_length || u6tx_length != u6rx_length || u3tx_length != u6tx_length)
            {
                rt_kprintf("echo test error!!!\r\n");
                return;
            }

            // 前面已经判断过4个值是否相等了
            if (u3tx_length != sendTotalCount)
            {
                rt_kprintf("发送数据不对等，echo test error!!!\r\n");
                return;
            }
        }
    }
}

static void self_tx_rx_u2_thread_entry(void *parameter)
{
    static char rx_buffer[1024 + 1];
    rt_ssize_t size;
    int count = 0;
    while (1)
    {
         size = rt_device_read(u2serial, 0, rx_buffer, 1000);

        u2rx_length += size;
    }
}

static void self_tx_rx_u5_thread_entry(void *parameter)
{
    static char rx_buffer[1024 + 1];

    while (1)
    {
        u5rx_length += rt_device_read(u5serial, 0, rx_buffer, 500);
    }
}

/**
 * @brief 测试思路,创建u2和u5线程接收自己的数据并记录接收长度，在当前线程u2和u5发送数据，等待数据发送完毕，判断发送数据长度和接收数据长度是否一致
 *
 * @param parameter
 */
static void self_tx_rx_test(void *parameter)
{
    static char tx_buffer[1024 + 1];
    for (uint32_t i = 0; i < sizeof(tx_buffer); i++)
        tx_buffer[i] = i;

    char *uart_name = "uart2";
    u2serial = rt_device_find(uart_name);
    if (!u2serial)
    {
        rt_kprintf("find %s failed!\n", uart_name);
        return;
    }
    rt_device_open(u2serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);

    char *uart5_name = "uart5";
    u5serial = rt_device_find(uart5_name);
    if (!u5serial)
    {
        rt_kprintf("find %s failed!\n", uart5_name);
        return;
    }
    rt_device_open(u5serial, RT_DEVICE_FLAG_RX_BLOCKING | RT_DEVICE_FLAG_TX_BLOCKING);

    rt_thread_startup(rt_thread_create("serial2", self_tx_rx_u2_thread_entry, RT_NULL, 2048, 6, 5));
    rt_thread_startup(rt_thread_create("serial5", self_tx_rx_u5_thread_entry, RT_NULL, 2048, 6, 5));

    for (uint32_t i = 0;; i++)
    {
        u2tx_length += rt_device_write(u2serial, 0, tx_buffer, 1000);
        u5tx_length += rt_device_write(u5serial, 0, tx_buffer, 500);

        rt_device_control(u2serial, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);
        rt_device_control(u5serial, RT_SERIAL_CTRL_TX_FLUSH, RT_NULL);

        // rt_thread_mdelay(10);

        if (i % 100 == 0)
        {
            rt_kprintf("self_test, uart2: tx: %ld, rx: %ld\r\n", u2tx_length, u2rx_length);
            rt_kprintf("self_test, uart5: tx: %ld, rx: %ld\r\n", u5tx_length, u5rx_length);
            if (u2tx_length != u2rx_length || u5tx_length != u5rx_length)
            {
                rt_kprintf("self test error!!!\r\n");
                return;
            }

            if (u5rx_length * 2 != u2rx_length)
            {
                rt_kprintf("数据不等长 self test error!!!\r\n");
                return;
            }
        }
    }
}

//
// uart_blocking_rx
// uart_blocking_tx
// testcases.drivers.uart_flush_rx
// testcases.drivers.uart_flush_txb
// testcases.drivers.uart_flush_txnb
// testcases.drivers.uart_get_unread_bytes_count
// uart_nonblocking_rx
// uart_nonblocking_tx
// testcases.drivers.uart_overflow_rxb_txb
// testcases.drivers.uart_rxb_txb
// testcases.drivers.uart_rxb_txnb
// testcases.drivers.uart_rxnb_txb
// testcases.drivers.uart_rxnb_txnb
// testcases.drivers.uart_timeout_rxb_txb

static int uart_test(void)
{
    rt_thread_startup(rt_thread_create("echo_test", echo_test, RT_NULL, 2048, 10, 5));

    rt_thread_startup(rt_thread_create("self_test", self_tx_rx_test, RT_NULL, 2048, 10, 5));
    return 0;
}

MSH_CMD_EXPORT_ALIAS(uart_test, uart_test, uart test);